#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<initializer_list>
#include<vector>
#include<string>
#include<functional>
#include<queue>
#include<unordered_map>
#include<set>
#include<algorithm>
using namespace std;
class A {
public:
    A() : _a(0), _b(0) {}

    void func() {
        cout << _a << _b << endl;
    }
    bool operator<(const A& other) const {
        if (_a != other._a) return _a < other._a;
        return _b < other._b;
    }
private:
    int _a;
    int _b;
};

int main() {
    set<A> s;
    A a1;
    A a2;
    s.insert(a1);
    s.insert(a2);

    for (A e : s) {
        e.func();
    }

    return 0;
}
//class A
//{
//public:
//	A()
//	{
//		_a = 0;
//		_b = 0;
//	}
//	void func()
//	{
//		cout << _a << _b << endl;
//	}
//private:
//	int _a;
//	int _b;
//};
//int main()
//{
//	set<A>s;
//	A a1;
//	A a2;
//	s.insert(a1);
//	s.insert(a2);
//	for (auto e : s)
//	{
//		e.func();
//	}
//	
//	return 0;
//}


//class Solution {
//public:
//    int dx[4] = { 0,0,1,-1 };
//    int dy[4] = { 1,-1,0,0 };
//    void solve(vector<vector<char>>& b) {
//        int m = b.size();
//        int n = b[0].size();
//        for (int i = 0; i < m; i++)
//        {
//            for (int j = 0; j < n; j++)
//            {
//                if (i == 0 || i == m - 1 || j == 0 || j == n - 1)
//                {
//                    if (b[i][j] == 'O')
//                    {
//                        queue<pair<int, int>>q;
//                        q.push({ i,j });
//                        b[i][j] = 'A';
//                        while (!q.empty())
//                        {
//                            auto tmp = q.front();
//                            q.pop();
//                            for (int k = 0; k < 4; k++)
//                            {
//                                int x = dx[k] + tmp.first;
//                                int y = dy[k] + tmp.second;
//                                if (x >= 0 && x < m && y >= 0 && y < n && b[x][y] == 'O')
//                                {
//                                    b[x][y] = 'A';
//                                    q.push({ x,y });
//                                }
//                            }
//                        }
//                    }
//                }
//            }
//        }
//        for (int i = 0; i < m; i++)
//        {
//            for (int j = 0; j < n; j++)
//            {
//                if (b[i][j] == 'O')b[i][j] = 'X';
//                else if (b[i][j] == 'A')b[i][j] = 'O';
//            }
//        }
//
//    }
//};
//int main()
//{
//    Solution s;
//    vector<vector<char>> ch = { {'X','X','X','X'},{'X','O','O','X'},{'X','X','O','X'},{'X','O','X','X'} };
//
//    s.solve(ch);
//    
//
//    return 0;
//}
//class A
//{
//public:
//	A(const int a=10):_a(a)
//	{
//
//	}
//
//	int add()
//	{
//		return _a + _b;
//	}
//	int _a;
//	int _b;
//};
//int main()
//{
//	/*char buffer[1024] = "name:juxinhao";
//	string s(buffer, buffer + 5);
//	cout << s << endl;
//	int n = strlen(buffer);
//	string s1(buffer + 5, buffer + n);
//	cout << s1 << endl;*/
//
//	vector<A>f; 
//	for (const auto& e : f)
//	{
//		e.add();
//	}
//	for ( const auto e : f)
//	{
//		e.add();
//	}
//
//	return 0;
//}
//class MedianFinder {
//public:
//    MedianFinder() {
//        n = 0;
//
//    }
//
//    void addNum(int num) {
//        int cur = n - 1;
//        f.resize(n + 1);
//        while (cur >= 0)
//        {
//            if (f[cur] > num)
//            {
//                f[cur + 1] = f[cur];
//                cur--;
//            }
//            else break;
//        }
//        f[cur + 1] = num;
//        n++;
//
//    }
//
//    double findMedian() {
//        if (n % 2)
//            return f[n / 2];
//        else return ((double)f[(n - 1) / 2] + (double)f[n / 2]) / 2.0;
//    }
//    vector<int>f;
//    int n;
//};
//int main()
//{
//    MedianFinder m;
//    m.addNum(1);
//    m.addNum(2);
//    cout << m.findMedian() << endl;
//    m.addNum(3);
//    cout << m.findMedian() << endl;
//    
//
//
//    return 0;
//}
//class Solution {
//public:
//    void add(string& ret, string& tmp)
//    {
//        string s;
//        int n1 = ret.size() - 1;
//        int n2 = tmp.size() - 1;
//        int sign = 0;
//        while (n1 >= 0 || n2 >= 0 || sign)
//        {
//            int a = 0;
//            if (n1 >= 0)a += ret[n1--] - '0';
//            if (n2 >= 0)a += tmp[n2--] - '0';
//            if (sign)a += sign;
//            sign = a / 10;
//            s += a % 10 + '0';
//        }
//        reverse(s.begin(), s.end());
//        ret = s;
//    }
//    string multiply(string s1, string s2) {
//        int n1 = s1.size();
//        int n2 = s2.size();
//        string ret;
//        for (int i = n2 - 1; i >= 0; i--)
//        {
//            int sign = 0;
//            string tmp;
//            int zero = n2 - 1 - i;
//            while (zero--)
//            {
//                tmp += '0';
//            }
//            for (int j = n1 - 1; j >= 0; j--)
//            {
//                int res = (s2[i] - '0') * (s1[j] - '0')+sign;
//                sign = res / 10;
//                tmp += (res % 10 + '0');
//            }
//            if (sign)tmp += (sign + '0');
//            reverse(tmp.begin(), tmp.end());
//            add(ret, tmp);
//        }
//        return ret;
//    }
//};
//int main()
//{
//    string s1 = "123";
//    string s2 = "456";
//    Solution s;
//   cout<< s.multiply(s1, s2);
//
//    return 0;
//}
//void Mergesort(vector<int>& f, vector<int>& tmp, int begin, int end)
//{
//	if (begin >= end)return;
//	int mid = (begin + end) / 2;
//	int begin1 = begin, end1 = mid;
//	int begin2 = mid + 1, end2 = end;
//	Mergesort(f, tmp, begin1, end1);
//	Mergesort(f, tmp, begin2, end2);
//	int cur = begin;
//	while (begin1 <= end1 && begin2 <= end2)
//	{
//		if (f[begin1] < f[begin2])
//		{
//			tmp[cur++] = f[begin1++];
//		}
//		else
//		{
//			tmp[cur++] = f[begin2++];
//		}
//	}
//	while (begin1 <= end1)
//	{
//		tmp[cur++] = f[begin1++];
//	}
//	while (begin2 <= end2)
//	{
//		tmp[cur++] = f[begin2++];
//	}
//
//	for (int i = begin; i <= end; i++)
//	{
//		f[i] = tmp[i];
//	}
//}
//class Solution {
//public:
//    void Merge(int& ret, vector<int>& tmp, vector<int>& nums, int begin, int end)
//    {
//        if (begin >= end)return;
//        int mid = (begin + end) / 2;
//        Merge(ret, nums, tmp, begin, mid);
//        Merge(ret, nums, tmp, mid + 1, end);
//        int cur1 = mid, cur2 = end;
//        while (cur1 >= begin && cur2 >= mid + 1)
//        {
//            if (nums[cur1] > nums[cur2])
//            {
//                ret += cur2 - (mid + 1) + 1;
//                cur1--;
//            }
//            else cur2--;
//        }
//        cur1 = begin; cur2 = mid + 1;
//        int cur3 = begin;
//        while (cur1 <= mid && cur2 <= end)
//        {
//            if (nums[cur1] < nums[cur2])tmp[cur3++] = nums[cur1++];
//            else tmp[cur3++] = nums[cur2++];
//        }
//        while (cur1 <= mid)tmp[cur3++] = nums[cur1++];
//        while (cur2 <= end)tmp[cur3++] = nums[cur2++];
//        for (int i = begin; i <= end; i++)nums[i] = tmp[i];
//
//    }
//    int reversePairs(vector<int>& nums) {
//        int ret = 0;
//        vector<int>tmp(nums.size());
//
//        Merge(ret, nums, tmp, 0, nums.size() - 1);
//        return ret;
//    }
//};
//int main()
//{
//    const char* str = "dafadf";
//    const string& name = str;
//    cout << (void*)str << endl;
//    cout << &name << endl;
//    /*vector<int>f = { 1,3,2,3,1 };
//    Solution s;
//    cout<<s.reversePairs(f);*/
//	/*vector<int>f = { 2,4,8,1,3,6,5,9,7,0 };
//	vector<int>tmp(f.size());
//	Mergesort(f, tmp, 0, f.size() - 1);
//	for (auto e : f)cout << e << ' ';*/
//	return 0;
//}
//int Sub(int a, int b,int c)
//{
//	return a - b-c;
//}
//
//class Solution {
//public:
//    string longestCommonPrefix(vector<string>& strs) {
//        int len = strs[0].size();
//        string ret;
//        for (int i = 1; i < strs.size(); i++)
//        {
//            len = min(len, strs[i].size());
//        }
//        for (int i = 0; i < len; i++)
//        {
//            for (int j = 0; j < strs.size() - 1; j++)
//            {
//                if (strs[j][i] != strs[j + 1][i])return ret;
//            }
//            ret += strs[0][i];
//        }
//        return ret;
//    }
//};
//class Solution {
//public:
//    long long sumDigitDifferences(vector<int>& nums) {
//        long long ret = 0;
//        int tmp = nums[0];
//        int num = 0;
//        while (tmp)
//        {
//            num++;
//            tmp /= 10;
//        }
//        while (num--)
//        {
//            unordered_map<int, int>hash;
//            for (auto& e : nums)
//            {
//                hash[e % 10]++;
//                e /= 10;
//            }
//            int sum = 0;
//            vector<int>f;
//            for (auto& e : hash)f.push_back(e.second);
//            for (int i = 0; i < f.size() - 1; i++)
//            {
//                for (int j = 1; j < f.size(); j++)sum += f[i] * f[j];
//            }
//            ret += sum;
//
//        }
//        return ret;
//    }
//
//};
//class Solution {
//public:
//    long long sumDigitDifferences(vector<int>& nums) {
//        long long ret = 0;
//        int tmp = nums[0];
//        int num = 0;
//        while (tmp)
//        {
//            num++;
//            tmp /= 10;
//        }
//        while (num--)
//        {
//            unordered_map<int, int>hash;
//            for (auto& e : nums)
//            {
//                hash[e % 10]++;
//                e /= 10;
//            }
//            long long sum = 0;
//            for (auto it = hash.begin(); it != hash.end(); it++)
//            {
//                for (auto it1 = next(it); it1 != hash.end(); ++it1)sum += (long long)it->second * it1->second;
//            }
//            ret += sum;
//
//        }
//        return ret;
//    }
//
//};
//class solution {
//public:
//    bool judge(vector<vector<char>>& grid, int row, int col)
//    {
//        int b = 0, w = 0;
//        for (int i = row; i <= row + 1; i++)
//        {
//            for (int j = col; j <= col + 1; j++)
//            {
//                if (grid[i][j] == 'B')b++;
//                else w++;
//            }
//        }
//        if (b == 3 && w == 1 || b == 1 && w == 3 || b == 4 || w == 4)return true;
//        else return false;
//    }
//    bool canMakeSquare(vector<vector<char>>& grid) {
//        int ret = false;
//        ret = judge(grid, 0, 0);
//        if (ret == true)return ret;
//        ret = judge(grid, 0, 1);
//        if (ret == true)return ret;
//        ret = judge(grid, 1, 0);
//        if (ret == true)return ret;
//
//        ret = judge(grid, 1, 1);
//        return true;
//
//
//    }
//};
//int main()
//{
//    vector<int>f = { 50,28,48 };
//    vector<vector<char>>v = { {'B','W','B'},{'W','B','W'},{'B','W','B'} };
//    solution s;
//    cout<<s.canMakeSquare(v);
//	/*auto f1 = bind(Sub, placeholders::_2,placeholders::_3, placeholders::_1);
//	cout<<f1(1, 5, 10);*/
//	return 0;
//}